#ifndef __PROCESS_POOL_HPP__
#define __PROCESS_POOL_HPP__

#include <iostream>
#include <cstdlib>
#include <vector>
#include <unistd.h>
#include <sys/wait.h>
#include "Task.hpp"

// 先描述
class Channel
{
public:
    Channel(int fd, pid_t id)
    : _wfd(fd),
    _subid(id)
    {
        _name = "channel-" + std::to_string(_wfd) + "-" + std::to_string(_subid);
    }
    ~Channel()
    {}
    void Send(int code)
    {
        int n = write(_wfd, &code, sizeof(code));
        (void)n;
    }
    void Close()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subid, nullptr, 0);
        (void)rid;
    }

    int Fd() {return _wfd; }
    pid_t SubId() { return _subid; }
    std::string Name() { return _name; }

private:
    int _wfd;
    pid_t _subid;
    std::string _name;
    // int _loadnum;
};

// 再组织
class ChannelManager
{
public:
    ChannelManager()
    :_next(0)
    {

    }

    void Insert(int wfd, pid_t subid)
    {
        _channels.emplace_back(wfd, subid); // emplace_back可以直接插入，不需要新建对象
        // Channel c(wfd, subid);   
        // _channels.push_back(std::move(c));
    }
    Channel &Select()
    {
        auto &c = _channels[_next];
        _next++;
        _next %= _channels.size();
        return c;
    }
    void PrintChannel()
    {
        for(auto &channel : _channels)
        {
            std::cout << channel.Name() << std::endl;
        }
    }

    // 关闭父进程与每个子进程的管道写端
    void StopSubProcess()
    {
        for(auto &channel : _channels)
        {
            channel.Close();
            std::cout << "关闭：" << channel.Name() << std::endl; 
        }
    }

    // wait等待回收子进程(父进程写端关闭之后，子进程执行Work函数的1.2:收到read返回值为0，子进程退出)
    void WaitSubProcess()
    {
        for(auto &channel : _channels)
        {
            channel.Wait();
            std::cout << "回收："<< channel.Name() << std::endl;
        }
    }

    void CloseAll()
    {
        for(auto &channel : _channels)
        {
            channel.Close();
            // std::cout << "关闭：" << channel.Name() << std::endl; 
        }
    }

    // Close和Wait分开写没问题
    // 但是将Close和Wait合起来写就出问题了
    // 问题原因:每当父进程指定一个写端，子进程也会将写端的fd继承，导致前面的进程的读端对应的写端有:父进程+后面的子进程的写端
    void CloseAndWait()
    {
        for(auto &channel : _channels)
        {
            channel.Close();
            std::cout << "关闭：" << channel.Name() << std::endl; 
            channel.Wait();
            std::cout << "回收："<< channel.Name() << std::endl;
        }

        // 1.解决方案1-倒叙关闭写端
        // for(int i = _channels.size() - 1; i >= 0; i--)
        // {
        //     _channels[i].Close();
        //     std::cout << "关闭：" << _channels[i].Name() << std::endl; 
        //     _channels[i].Wait();
        //     std::cout << "回收："<< _channels[i].Name() << std::endl;
        // }

        // 2.解决方案2-在创建时关闭多余的写端(在Start中实现)
    }

private:
    std::vector<Channel> _channels;
    int _next;
};

const int gdefaultnum = 5;

class ProcessPool
{
public:
    ProcessPool(int num)
    :_process_num(num)
    {
        _tm.Register(PrintLog);
        _tm.Register(Download);
        _tm.Register(Upload);
    }

    // 在父进程执行Run之后，子进程的read接收到信息，开始执行指定的任务。
    // 0.子进程read之后阻塞等待父进程发送任务码
    // 1.1对应管道的子进程接收到任务码执行 父进程要求的任务
    // 1.2当子进程接收到的任务码为0时(即父进程调用Stop函数关闭管道之后)，子进程的循环退出，子进程运行结束
    void Work(int rfd)
    {
        while(true)
        {
            int code = 0;
            ssize_t n = read(rfd, &code, sizeof(code));
            if(n > 0)
            {
                if(n != sizeof(code))
                {
                    continue;
                }
                std::cout << "子进程[" << getpid() << "]收到一个任务码：" << code << std::endl;
                _tm.Execute(code);
            }
            else if(n == 0)
            {
                std::cout << "子进程退出" << std::endl;
                break;
            }
            else
            {
                std::cout << "读取错误" << std::endl;
                break;
            }
        }
    }

    // 1.创建_process_num个子进程，每个子进程使用管道与父进程连接
    // 2.子进程Work()函数中的read阻塞等待父进程发送任务码，执行对应的进程
    // 3.父进程保存每个子进程的id号，以便后续通过不同的子进程执行不同的任务
    bool Start()
    {
        for(int i = 0; i < _process_num; i++)
        {
            // 1.创建管道 
            int pipefd[2] = {0};
            int n = pipe(pipefd);
            if(n < 0)
                return false;

            // 2.创建子进程
            pid_t subid = fork();
            if(subid < 0)
                return false;
            else if(subid == 0)
            {
                // 子进程创建
                // 让子进程自己关闭自己继承下来的他的哥哥进程的w端就行了
                std::cout << "#####################" << "第" << i << "次" << std::endl;
                _cm.PrintChannel();
                std::cout << "#####################" << std::endl;
                _cm.CloseAll();
                // 3.关闭不需要的文件描述符
                close(pipefd[1]); 
                Work(pipefd[0]); 
                close(pipefd[0]);
                exit(0);
            }
            else
            {
                sleep(1);
                // 父进程
                // 3. 关闭不需要的文件描述符，并存储每个子进程的id号
                close(pipefd[0]);   // 读端 ：pipefd[0]
                _cm.Insert(pipefd[1], subid);
                // wfd, subid
            }
        }
        return true;
    }

    // 打印子进程文件描述符_wfd，PID
    void Debug()
    {
        _cm.PrintChannel();
    }

    // 1.选择任务
    // 2.选择管道
    // 3.父进程发送任务码，写入到选定的管道
    void Run()
    {
        // 1.选择一个任务
        int taskcode = _tm.Code();
        std::cout << "选择一个任务码：" << taskcode << std::endl;

        // 2.选择一个信道[子进程]，负载均衡的选择一个子进程
        auto &c = _cm.Select(); // 调用ChannelManager类中的信道选择函数Select()
        std::cout << "选择一个管道 & 子进程：" << taskcode << std::endl;

        // 3.发送任务：在指定管道中 向父进程写入任务码 子进程经过管道接收到任务码之后执行
        c.Send(taskcode);
        std::cout << "发送一个任务码：" << taskcode << std::endl;
    }

    void Stop()
    {
        _cm.CloseAndWait();

        // //关闭父进程所有的wfd即可
        // _cm.StopSubProcess();
        // // 回收所有子进程
        // _cm.WaitSubProcess();
    }
    ~ProcessPool()
    {

    }
private:
    ChannelManager _cm;
    int _process_num;
    TaskManager _tm;
};

#endif
